#include "Constantes_Globals.h"

int file_exists(const char *filename)
{
    FILE *f;
    if(f = fopen(filename, "r"))
    {
        fclose(f);
        return 1;
    }
    return 0;
}


void salvar_memVir(memVir *mem, int qtd)
{
    int aux;
    FILE* f;

    if(file_exists("C:/memoria_virtual.txt"))
    {
        f = fopen("C:/memoria_virtual.txt","r+b");

        // Atualiza o novo numero de registros do arquivo
        fread(&aux,sizeof(int),1,f);
        printf("Valor recuperado de aux na função salvar %d", aux);
        fclose(f);

        f = fopen("C:/memoria_virtual.txt","r+b");
        aux = aux + qtd;
        fwrite(&aux,sizeof(aux),1,f);
        printf("Valor gravado com sucesso na função salvar %d!\n", aux);
        fclose(f);

        // Atualiza a quantidade de registros
        f = fopen("C:/memoria_virtual.txt","ab");
        fwrite(mem,sizeof(memVir),qtd,f);
        fclose(f);	
    }
    else
    {
        // Cria arquivo para leitura e escrita começando da primeira linha
        f = fopen("C:/memoria_virtual.txt","w+b");

        fwrite(&qtd,sizeof(qtd),1,f);
        printf("Quantidade %d salva com sucesso!\n", qtd);
        fclose(f);

        f = fopen("C:/memoria_virtual.txt","r+b");

        // possivel erro
        fseek(f,sizeof(memVir),SEEK_END);
        printf("Estrutura salva com sucesso!\n");
        fwrite(mem,sizeof(memVir),qtd,f);
        fclose(f);					
    }	
}

int qtd_registros()
{
    FILE* f;
    int aux;

    if(file_exists("C:/memoria_virtual.txt"))
    {	
        f = fopen("C:/memoria_virtual.txt","rb");

        if(f == NULL)
        {
            printf("erro ao abrir o arquivo!");
            return;
        }

        rewind(f);
        fread(&aux,sizeof(aux),1,f);
        rewind(f);
        printf("\nO arquivo contém %d registros.\n", aux);
        return aux;		
    }
    else
    {
        printf("\nO arquivo não existe!\n");
        return 0;
    }
}


void atualizaReg(int n) 
{
    FILE* f;
    int aux;

    if(file_exists("C:/memoria_virtual.txt"))
    {
        f = fopen("C:/memoria_virtual.txt","r+b");
        fread(&aux,sizeof(aux),1,f);
        printf("Item recuperado com sucesso!\nValor = %d\n", aux);
        fclose(f);

        f = fopen("C:/memoria_virtual.txt","r+b");
        aux = aux + n;
        fwrite(&aux,sizeof(aux),1,f);
        printf("Item gravado com sucesso!\n\n");
        fclose(f);
    }
    else
    {
        f = fopen("C:/memoria_virtual.txt","w+b");

        aux = n;
        fwrite(&aux,sizeof(aux),1,f);
        printf("Item gravado com sucesso!\n\n");
        fclose(f);
    }

}

memVir* carrega_memVir()
{
    FILE* f;
    memVir *mem;
    int aux;	

    if(file_exists("C:/memoria_virtual.txt"))
    {
        f = fopen("C:/memoria_virtual.txt","r+b");
        fread(&aux,sizeof(aux),1,f);
        printf("Item recuperado com sucesso!\nValor = %d\n", aux);
        fclose(f);

        mem = (memVir *) malloc(aux * sizeof(memVir));

        f = fopen("C:/memoria_virtual.txt","r+b");
        fseek(f,sizeof(int) + sizeof(memVir),SEEK_SET);
        fread(mem,sizeof(memVir),aux,f);
        fclose(f);

        return mem;			

    }
    else
    {
        printf("\nO arquivo não existe!\n");
        return NULL;
    }
}


void salvar_mem(mem *mem, int qtd)
{
    int aux;
    FILE* f;

    if(file_exists("memoria"))
    {
        f = fopen("memoria","r+b");

        // Atualiza o novo numero de registros do arquivo
        fread(&aux,sizeof(int),1,f);
        printf("Valor recuperado de aux na função salvar %d", aux);
        fclose(f);

        f = fopen("memoria","r+b");
        aux = aux + qtd;
        fwrite(&aux,sizeof(aux),1,f);
        printf("Valor gravado com sucesso na função salvar %d!\n", aux);
        fclose(f);

        // Atualiza a quantidade de registros
        f = fopen("memoria","ab");
        fwrite(mem,sizeof(mem),qtd,f);
        fclose(f);	
    }
    else
    {
        // Cria arquivo para leitura e escrita começando da primeira linha
        f = fopen("memoria","w+b");

        fwrite(&qtd,sizeof(qtd),1,f);
        printf("Quantidade %d salva com sucesso!\n", qtd);
        fclose(f);

        f = fopen("memoria","r+b");

        // possivel erro
        fseek(f,sizeof(mem),SEEK_END);
        printf("Estrutura salva com sucesso!\n");
        fwrite(mem,sizeof(mem),qtd,f);
        fclose(f);					
    }	
}

/*mem* carrega_mem()
{
    FILE* f;
    mem *mem;
    int aux;	

    if(file_exists("memoria"))
    {
        f = fopen("memoria","r+b");
        fread(&aux,sizeof(aux),1,f);
        printf("Item recuperado com sucesso!\nValor = %d\n", aux);
        fclose(f);

        mem = (mem *) malloc(aux * sizeof(mem));

        f = fopen("memoria","r+b");
        fseek(f,sizeof(int) + sizeof(mem),SEEK_SET);
        fread(mem,sizeof(mem),aux,f);
        fclose(f);

        return mem;			

    }
    else
    {
        printf("\nO arquivo não existe!\n");
        return NULL;
    }
}
*/
mem* carrega_mem()
{
  FILE* f;
  mem *memoria;
  int aux;	
   
  if(file_exists("memoria"))
  {
    f = fopen("memoria","r+b");        
    fread(&aux,sizeof(aux),1,f);
    printf("Item recuperado com sucesso!\nValor = %d\n", aux);
    fclose(f);
         
    memoria = (mem *) malloc(aux * sizeof (mem));
        
    f = fopen("memoria","r+b");
    fseek(f,sizeof(int) + sizeof(mem),SEEK_SET);
    fread(memoria,sizeof(mem),aux,f);
    fclose(f);
   
    return memoria;			
  }
  else
  {
    printf("\nO arquivo não existe!\n");
        
    return NULL;
    }
}

/*
memVir* busca_memVir(int pagina)
{
    memVir *mem;
    memVir *memAux;
    int n;
    int i;

    if(file_exists("memoria_virtual"))
    {
        n = qtd_registros();
        mem = (memVir *) malloc(n * sizeof(memVir));

        mem = carrega_memVir();

        memAux = (memVir *) malloc(sizeof(memVir));

        for(i = 0; i < n; i++)
        {
            if(mem[i].molduraPagina == pagina)
            {
                memAux[0].id = mem[i].id;
                memAux[0].instrucao = mem[i].instrucao;
                memAux[0].molduraPagina = mem[i].molduraPagina;
                memAux[0].presenteAusente = mem[i].presenteAusente;
                memAux[0].protecaoLeitura = mem[i].protecaoLeitura;
                memAux[0].protecaoEscrita = mem[i].protecaoEscrita;
                memAux[0].protecaoExecucao = mem[i].protecaoExecucao;
                memAux[0].modificada = mem[i].modificada;
                memAux[0].referenciada = mem[i].referenciada;
                memAux[0].desabilitaCache = mem[i].desabilitaCache;
                break;
            }
        }

        return memAux;
    }
    else
    {
        printf("O arquivo não existe\n");
        return memAux;
    } 

}
*/
/*
int main(int argc, char** argv) 
{
        int n = 3;
        int i;
        memVir *in;
        memVir *out;

        in = (memVir *) malloc(n * sizeof(memVir));


        in[0].id = 7;
        in[0].instrucao = 1000;
        in[0].molduraPagina = 1;

        in[1].id = 10;
        in[1].instrucao = 200;
        in[1].molduraPagina = 2;

        in[2].id = 15;
        in[2].instrucao = 3000;
        in[2].molduraPagina = 3;


        salvar_memVir(in,n);
*/

        /*in = (memVir *) malloc(2 * sizeof(memVir));

        in[0].id = 11;
        in[0].instrucao = 11000;
        in[0].molduraPagina = 5;

        in[1].id = 20;
        in[1].instrucao = 5;
        in[1].molduraPagina = 6;

        salvar_memVir(in,2);

        out = (memVir *) malloc(6 * sizeof(memVir));
        out = carrega_memVir();

        for(i = 0; i < 6; i++)
        {
                printf("id - %d\n", out[i].id);
                printf("instrucao - %d\n", out[i].instrucao);
                printf("molduraPagina - %d\n", out[i].molduraPagina);
        }
/////// -->
        out = (memVir *) malloc(sizeof(memVir));
        out = busca_memVir(0);

                for(i = 0; i < 1; i++)
                {
                        printf("id - %d\n", out[i].id);
                        printf("instrucao - %d\n", out[i].instrucao);
                        printf("molduraPagina - %d\n", out[i].molduraPagina);
                }

        return 0;	

}
      
*/

/*
 *  AS FUNCOES ABAIXO SAO REPONSAVEIS POR SALVAR E RECUPERAR UMA PAGINA.
 

void salvar_PAGINA(pagina *pag, int qtd)
{
    int aux;
    FILE* f;

    if(file_exists("pagina_memoria"))
    {
        f = fopen("pagina_memoria","r+b");

        // Atualiza o novo numero de registros do arquivo
        fread(&aux,sizeof(int),1,f);
        printf("Dado recuperado de aux na função salvar %d", aux);
        fclose(f);

        f = fopen("pagina_memoria","r+b");
        aux = aux + qtd;
        fwrite(&aux,sizeof(aux),1,f);
        printf("Dado gravado com sucesso na função salvar %d!\n", aux);
        fclose(f);

        // Atualiza a quantidade de registros
        f = fopen("pagina_memoria","ab");
        fwrite(pag,sizeof(pagina),qtd,f);
        fclose(f);	
    }
    else
    {
        // Cria arquivo para leitura e escrita começando da primeira linha
        f = fopen("pagina_memoria","w+b");

        fwrite(&qtd,sizeof(qtd),1,f);
        printf("Quantidade %d salva com sucesso!\n", qtd);
        fclose(f);

        f = fopen("C:/memoria_virtual.txt","r+b");

        // possivel erro
        fseek(f,sizeof(pagina),SEEK_END);
        printf("Estrutura salva com sucesso!\n");
        fwrite(pag,sizeof(pagina),qtd,f);
        fclose(f);					
    }	
}


pagina* carrega_pagina()
{
    FILE* f;
    pagina *pag;
    int aux;	

    if(file_exists("pagina_memoria"))
    {
        f = fopen("pagina_memoria","r+b");
        fread(&aux,sizeof(aux),1,f);
        printf("Item recuperado com sucesso!\nValor = %d\n", aux);
        fclose(f);

        pag = (pagina *) malloc(aux * sizeof(pagina));

        f = fopen("pagina_memoria","r+b");
        fseek(f,sizeof(int) + sizeof(pagina),SEEK_SET);
        fread(pag,sizeof(pagina),aux,f);
        fclose(f);

        return pag;			

    }
    else
    {
        printf("\nO arquivo não existe!\n");
        return NULL;
    }
}
 * */